// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.tmp.jm.goods.order;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.TmpJmGoodsOrder;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(TmpJmGoodsOrder.class)
@Setter
@Getter
public class TmpJmGoodsOrderSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "TmpJmGoodsOrder".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 驳回理由(模糊搜索)
   */
  private String reasonForRejection;

  /**
   * 驳回理由 比较(eq)
   */
  private String reasonForRejectionEq;
  /**
   * 驳回理由 比较(neq)
   */
  private String reasonForRejectionNeq;
  /**
   * 驳回理由 比较(gt)
   */
  private String reasonForRejectionGt;
  /**
   * 驳回理由 比较(gte)
   */
  private String reasonForRejectionGte;
  /**
   * 驳回理由 比较(lt)
   */
  private String reasonForRejectionLt;
  /**
   * 驳回理由 比较(lte)
   */
  private String reasonForRejectionLte;
  /**
   * 驳回理由 比较(contains)
   */
  private String reasonForRejectionContains;
  /**
   * 驳回理由 比较(notcontains)
   */
  private String reasonForRejectionNotcontains;
  /**
   * 驳回理由 比较(startswith)
   */
  private String reasonForRejectionStartswith;
  /**
   * 驳回理由 比较(endswith)
   */
  private String reasonForRejectionEndswith;
  /**
   * 驳回理由 比较(isnull)
   */
  private Boolean reasonForRejectionIsnull;
  /**
   * 驳回理由 比较(isnotnull)
   */
  private Boolean reasonForRejectionIsnotnull;

  /**
   * 驳回理由(精确搜索)
   */
  private List<String> reasonForRejectionInList;

  /**
   * 物流公司(模糊搜索)
   */
  private String logisticsCompany;

  /**
   * 物流公司 比较(eq)
   */
  private String logisticsCompanyEq;
  /**
   * 物流公司 比较(neq)
   */
  private String logisticsCompanyNeq;
  /**
   * 物流公司 比较(gt)
   */
  private String logisticsCompanyGt;
  /**
   * 物流公司 比较(gte)
   */
  private String logisticsCompanyGte;
  /**
   * 物流公司 比较(lt)
   */
  private String logisticsCompanyLt;
  /**
   * 物流公司 比较(lte)
   */
  private String logisticsCompanyLte;
  /**
   * 物流公司 比较(contains)
   */
  private String logisticsCompanyContains;
  /**
   * 物流公司 比较(notcontains)
   */
  private String logisticsCompanyNotcontains;
  /**
   * 物流公司 比较(startswith)
   */
  private String logisticsCompanyStartswith;
  /**
   * 物流公司 比较(endswith)
   */
  private String logisticsCompanyEndswith;
  /**
   * 物流公司 比较(isnull)
   */
  private Boolean logisticsCompanyIsnull;
  /**
   * 物流公司 比较(isnotnull)
   */
  private Boolean logisticsCompanyIsnotnull;

  /**
   * 物流公司(精确搜索)
   */
  private List<String> logisticsCompanyInList;

  /**
   * 物流单号(模糊搜索)
   */
  private String logisticsNo;

  /**
   * 物流单号 比较(eq)
   */
  private String logisticsNoEq;
  /**
   * 物流单号 比较(neq)
   */
  private String logisticsNoNeq;
  /**
   * 物流单号 比较(gt)
   */
  private String logisticsNoGt;
  /**
   * 物流单号 比较(gte)
   */
  private String logisticsNoGte;
  /**
   * 物流单号 比较(lt)
   */
  private String logisticsNoLt;
  /**
   * 物流单号 比较(lte)
   */
  private String logisticsNoLte;
  /**
   * 物流单号 比较(contains)
   */
  private String logisticsNoContains;
  /**
   * 物流单号 比较(notcontains)
   */
  private String logisticsNoNotcontains;
  /**
   * 物流单号 比较(startswith)
   */
  private String logisticsNoStartswith;
  /**
   * 物流单号 比较(endswith)
   */
  private String logisticsNoEndswith;
  /**
   * 物流单号 比较(isnull)
   */
  private Boolean logisticsNoIsnull;
  /**
   * 物流单号 比较(isnotnull)
   */
  private Boolean logisticsNoIsnotnull;

  /**
   * 物流单号(精确搜索)
   */
  private List<String> logisticsNoInList;

  /**
   * 用户留言(模糊搜索)
   */
  private String message;

  /**
   * 用户留言 比较(eq)
   */
  private String messageEq;
  /**
   * 用户留言 比较(neq)
   */
  private String messageNeq;
  /**
   * 用户留言 比较(gt)
   */
  private String messageGt;
  /**
   * 用户留言 比较(gte)
   */
  private String messageGte;
  /**
   * 用户留言 比较(lt)
   */
  private String messageLt;
  /**
   * 用户留言 比较(lte)
   */
  private String messageLte;
  /**
   * 用户留言 比较(contains)
   */
  private String messageContains;
  /**
   * 用户留言 比较(notcontains)
   */
  private String messageNotcontains;
  /**
   * 用户留言 比较(startswith)
   */
  private String messageStartswith;
  /**
   * 用户留言 比较(endswith)
   */
  private String messageEndswith;
  /**
   * 用户留言 比较(isnull)
   */
  private Boolean messageIsnull;
  /**
   * 用户留言 比较(isnotnull)
   */
  private Boolean messageIsnotnull;

  /**
   * 用户留言(精确搜索)
   */
  private List<String> messageInList;

  /**
   * 订单id(模糊搜索)
   */
  private String orderId;

  /**
   * 订单id 比较(eq)
   */
  private String orderIdEq;
  /**
   * 订单id 比较(neq)
   */
  private String orderIdNeq;
  /**
   * 订单id 比较(gt)
   */
  private String orderIdGt;
  /**
   * 订单id 比较(gte)
   */
  private String orderIdGte;
  /**
   * 订单id 比较(lt)
   */
  private String orderIdLt;
  /**
   * 订单id 比较(lte)
   */
  private String orderIdLte;
  /**
   * 订单id 比较(contains)
   */
  private String orderIdContains;
  /**
   * 订单id 比较(notcontains)
   */
  private String orderIdNotcontains;
  /**
   * 订单id 比较(startswith)
   */
  private String orderIdStartswith;
  /**
   * 订单id 比较(endswith)
   */
  private String orderIdEndswith;
  /**
   * 订单id 比较(isnull)
   */
  private Boolean orderIdIsnull;
  /**
   * 订单id 比较(isnotnull)
   */
  private Boolean orderIdIsnotnull;

  /**
   * 订单id(精确搜索)
   */
  private List<String> orderIdInList;

  /**
   * 最早下单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderTimeStart;

  /**
   * 最晚下单时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date orderTimeEnd;

  /**
   * 下单时间 比较(eq)
   */
  private Date orderTimeEq;
  /**
   * 下单时间 比较(neq)
   */
  private Date orderTimeNeq;
  /**
   * 下单时间 比较(gt)
   */
  private Date orderTimeGt;
  /**
   * 下单时间 比较(gte)
   */
  private Date orderTimeGte;
  /**
   * 下单时间 比较(lt)
   */
  private Date orderTimeLt;
  /**
   * 下单时间 比较(lte)
   */
  private Date orderTimeLte;
  /**
   * 下单时间 比较(contains)
   */
  private Date orderTimeContains;
  /**
   * 下单时间 比较(notcontains)
   */
  private Date orderTimeNotcontains;
  /**
   * 下单时间 比较(startswith)
   */
  private Date orderTimeStartswith;
  /**
   * 下单时间 比较(endswith)
   */
  private Date orderTimeEndswith;
  /**
   * 下单时间 比较(isnull)
   */
  private Boolean orderTimeIsnull;
  /**
   * 下单时间 比较(isnotnull)
   */
  private Boolean orderTimeIsnotnull;

  /**
   * 实收款
   */
  private java.math.BigDecimal payment;

  /**
   * 最小实收款
   */
  private java.math.BigDecimal paymentMin;

  /**
   * 最大实收款
   */
  private java.math.BigDecimal paymentMax;

  /**
   * 实收款 比较(eq)
   */
  private java.math.BigDecimal paymentEq;
  /**
   * 实收款 比较(neq)
   */
  private java.math.BigDecimal paymentNeq;
  /**
   * 实收款 比较(gt)
   */
  private java.math.BigDecimal paymentGt;
  /**
   * 实收款 比较(gte)
   */
  private java.math.BigDecimal paymentGte;
  /**
   * 实收款 比较(lt)
   */
  private java.math.BigDecimal paymentLt;
  /**
   * 实收款 比较(lte)
   */
  private java.math.BigDecimal paymentLte;
  /**
   * 实收款 比较(contains)
   */
  private java.math.BigDecimal paymentContains;
  /**
   * 实收款 比较(notcontains)
   */
  private java.math.BigDecimal paymentNotcontains;
  /**
   * 实收款 比较(startswith)
   */
  private java.math.BigDecimal paymentStartswith;
  /**
   * 实收款 比较(endswith)
   */
  private java.math.BigDecimal paymentEndswith;
  /**
   * 实收款 比较(isnull)
   */
  private Boolean paymentIsnull;
  /**
   * 实收款 比较(isnotnull)
   */
  private Boolean paymentIsnotnull;

  /**
   * 支付方式(模糊搜索)
   */
  private String paymentMethod;

  /**
   * 支付方式 比较(eq)
   */
  private String paymentMethodEq;
  /**
   * 支付方式 比较(neq)
   */
  private String paymentMethodNeq;
  /**
   * 支付方式 比较(gt)
   */
  private String paymentMethodGt;
  /**
   * 支付方式 比较(gte)
   */
  private String paymentMethodGte;
  /**
   * 支付方式 比较(lt)
   */
  private String paymentMethodLt;
  /**
   * 支付方式 比较(lte)
   */
  private String paymentMethodLte;
  /**
   * 支付方式 比较(contains)
   */
  private String paymentMethodContains;
  /**
   * 支付方式 比较(notcontains)
   */
  private String paymentMethodNotcontains;
  /**
   * 支付方式 比较(startswith)
   */
  private String paymentMethodStartswith;
  /**
   * 支付方式 比较(endswith)
   */
  private String paymentMethodEndswith;
  /**
   * 支付方式 比较(isnull)
   */
  private Boolean paymentMethodIsnull;
  /**
   * 支付方式 比较(isnotnull)
   */
  private Boolean paymentMethodIsnotnull;

  /**
   * 支付方式(精确搜索)
   */
  private List<String> paymentMethodInList;

  /**
   * 最早付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date paymentTimeStart;

  /**
   * 最晚付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date paymentTimeEnd;

  /**
   * 付款时间 比较(eq)
   */
  private Date paymentTimeEq;
  /**
   * 付款时间 比较(neq)
   */
  private Date paymentTimeNeq;
  /**
   * 付款时间 比较(gt)
   */
  private Date paymentTimeGt;
  /**
   * 付款时间 比较(gte)
   */
  private Date paymentTimeGte;
  /**
   * 付款时间 比较(lt)
   */
  private Date paymentTimeLt;
  /**
   * 付款时间 比较(lte)
   */
  private Date paymentTimeLte;
  /**
   * 付款时间 比较(contains)
   */
  private Date paymentTimeContains;
  /**
   * 付款时间 比较(notcontains)
   */
  private Date paymentTimeNotcontains;
  /**
   * 付款时间 比较(startswith)
   */
  private Date paymentTimeStartswith;
  /**
   * 付款时间 比较(endswith)
   */
  private Date paymentTimeEndswith;
  /**
   * 付款时间 比较(isnull)
   */
  private Boolean paymentTimeIsnull;
  /**
   * 付款时间 比较(isnotnull)
   */
  private Boolean paymentTimeIsnotnull;

  /**
   * 联系方式(模糊搜索)
   */
  private String phone;

  /**
   * 联系方式 比较(eq)
   */
  private String phoneEq;
  /**
   * 联系方式 比较(neq)
   */
  private String phoneNeq;
  /**
   * 联系方式 比较(gt)
   */
  private String phoneGt;
  /**
   * 联系方式 比较(gte)
   */
  private String phoneGte;
  /**
   * 联系方式 比较(lt)
   */
  private String phoneLt;
  /**
   * 联系方式 比较(lte)
   */
  private String phoneLte;
  /**
   * 联系方式 比较(contains)
   */
  private String phoneContains;
  /**
   * 联系方式 比较(notcontains)
   */
  private String phoneNotcontains;
  /**
   * 联系方式 比较(startswith)
   */
  private String phoneStartswith;
  /**
   * 联系方式 比较(endswith)
   */
  private String phoneEndswith;
  /**
   * 联系方式 比较(isnull)
   */
  private Boolean phoneIsnull;
  /**
   * 联系方式 比较(isnotnull)
   */
  private Boolean phoneIsnotnull;

  /**
   * 联系方式(精确搜索)
   */
  private List<String> phoneInList;

  /**
   * 优惠信息(模糊搜索)
   */
  private String preferential;

  /**
   * 优惠信息 比较(eq)
   */
  private String preferentialEq;
  /**
   * 优惠信息 比较(neq)
   */
  private String preferentialNeq;
  /**
   * 优惠信息 比较(gt)
   */
  private String preferentialGt;
  /**
   * 优惠信息 比较(gte)
   */
  private String preferentialGte;
  /**
   * 优惠信息 比较(lt)
   */
  private String preferentialLt;
  /**
   * 优惠信息 比较(lte)
   */
  private String preferentialLte;
  /**
   * 优惠信息 比较(contains)
   */
  private String preferentialContains;
  /**
   * 优惠信息 比较(notcontains)
   */
  private String preferentialNotcontains;
  /**
   * 优惠信息 比较(startswith)
   */
  private String preferentialStartswith;
  /**
   * 优惠信息 比较(endswith)
   */
  private String preferentialEndswith;
  /**
   * 优惠信息 比较(isnull)
   */
  private Boolean preferentialIsnull;
  /**
   * 优惠信息 比较(isnotnull)
   */
  private Boolean preferentialIsnotnull;

  /**
   * 优惠信息(精确搜索)
   */
  private List<String> preferentialInList;

  /**
   * 单价
   */
  private java.math.BigDecimal price;

  /**
   * 最小单价
   */
  private java.math.BigDecimal priceMin;

  /**
   * 最大单价
   */
  private java.math.BigDecimal priceMax;

  /**
   * 单价 比较(eq)
   */
  private java.math.BigDecimal priceEq;
  /**
   * 单价 比较(neq)
   */
  private java.math.BigDecimal priceNeq;
  /**
   * 单价 比较(gt)
   */
  private java.math.BigDecimal priceGt;
  /**
   * 单价 比较(gte)
   */
  private java.math.BigDecimal priceGte;
  /**
   * 单价 比较(lt)
   */
  private java.math.BigDecimal priceLt;
  /**
   * 单价 比较(lte)
   */
  private java.math.BigDecimal priceLte;
  /**
   * 单价 比较(contains)
   */
  private java.math.BigDecimal priceContains;
  /**
   * 单价 比较(notcontains)
   */
  private java.math.BigDecimal priceNotcontains;
  /**
   * 单价 比较(startswith)
   */
  private java.math.BigDecimal priceStartswith;
  /**
   * 单价 比较(endswith)
   */
  private java.math.BigDecimal priceEndswith;
  /**
   * 单价 比较(isnull)
   */
  private Boolean priceIsnull;
  /**
   * 单价 比较(isnotnull)
   */
  private Boolean priceIsnotnull;

  /**
   * 审核驳回原因(模糊搜索)
   */
  private String processRejectReason;

  /**
   * 审核驳回原因 比较(eq)
   */
  private String processRejectReasonEq;
  /**
   * 审核驳回原因 比较(neq)
   */
  private String processRejectReasonNeq;
  /**
   * 审核驳回原因 比较(gt)
   */
  private String processRejectReasonGt;
  /**
   * 审核驳回原因 比较(gte)
   */
  private String processRejectReasonGte;
  /**
   * 审核驳回原因 比较(lt)
   */
  private String processRejectReasonLt;
  /**
   * 审核驳回原因 比较(lte)
   */
  private String processRejectReasonLte;
  /**
   * 审核驳回原因 比较(contains)
   */
  private String processRejectReasonContains;
  /**
   * 审核驳回原因 比较(notcontains)
   */
  private String processRejectReasonNotcontains;
  /**
   * 审核驳回原因 比较(startswith)
   */
  private String processRejectReasonStartswith;
  /**
   * 审核驳回原因 比较(endswith)
   */
  private String processRejectReasonEndswith;
  /**
   * 审核驳回原因 比较(isnull)
   */
  private Boolean processRejectReasonIsnull;
  /**
   * 审核驳回原因 比较(isnotnull)
   */
  private Boolean processRejectReasonIsnotnull;

  /**
   * 审核驳回原因(精确搜索)
   */
  private List<String> processRejectReasonInList;

  /**
   * 保护计划id
   */
  private Long protectionId;

  /**
   * 最小保护计划id
   */
  private Long protectionIdMin;

  /**
   * 最大保护计划id
   */
  private Long protectionIdMax;

  /**
   * 保护计划id 比较(eq)
   */
  private Long protectionIdEq;
  /**
   * 保护计划id 比较(neq)
   */
  private Long protectionIdNeq;
  /**
   * 保护计划id 比较(gt)
   */
  private Long protectionIdGt;
  /**
   * 保护计划id 比较(gte)
   */
  private Long protectionIdGte;
  /**
   * 保护计划id 比较(lt)
   */
  private Long protectionIdLt;
  /**
   * 保护计划id 比较(lte)
   */
  private Long protectionIdLte;
  /**
   * 保护计划id 比较(contains)
   */
  private Long protectionIdContains;
  /**
   * 保护计划id 比较(notcontains)
   */
  private Long protectionIdNotcontains;
  /**
   * 保护计划id 比较(startswith)
   */
  private Long protectionIdStartswith;
  /**
   * 保护计划id 比较(endswith)
   */
  private Long protectionIdEndswith;
  /**
   * 保护计划id 比较(isnull)
   */
  private Boolean protectionIdIsnull;
  /**
   * 保护计划id 比较(isnotnull)
   */
  private Boolean protectionIdIsnotnull;

  /**
   * 数量
   */
  private Long quantity;

  /**
   * 最小数量
   */
  private Long quantityMin;

  /**
   * 最大数量
   */
  private Long quantityMax;

  /**
   * 数量 比较(eq)
   */
  private Long quantityEq;
  /**
   * 数量 比较(neq)
   */
  private Long quantityNeq;
  /**
   * 数量 比较(gt)
   */
  private Long quantityGt;
  /**
   * 数量 比较(gte)
   */
  private Long quantityGte;
  /**
   * 数量 比较(lt)
   */
  private Long quantityLt;
  /**
   * 数量 比较(lte)
   */
  private Long quantityLte;
  /**
   * 数量 比较(contains)
   */
  private Long quantityContains;
  /**
   * 数量 比较(notcontains)
   */
  private Long quantityNotcontains;
  /**
   * 数量 比较(startswith)
   */
  private Long quantityStartswith;
  /**
   * 数量 比较(endswith)
   */
  private Long quantityEndswith;
  /**
   * 数量 比较(isnull)
   */
  private Boolean quantityIsnull;
  /**
   * 数量 比较(isnotnull)
   */
  private Boolean quantityIsnotnull;

  /**
   * 取消理由(模糊搜索)
   */
  private String reasonForCancellation;

  /**
   * 取消理由 比较(eq)
   */
  private String reasonForCancellationEq;
  /**
   * 取消理由 比较(neq)
   */
  private String reasonForCancellationNeq;
  /**
   * 取消理由 比较(gt)
   */
  private String reasonForCancellationGt;
  /**
   * 取消理由 比较(gte)
   */
  private String reasonForCancellationGte;
  /**
   * 取消理由 比较(lt)
   */
  private String reasonForCancellationLt;
  /**
   * 取消理由 比较(lte)
   */
  private String reasonForCancellationLte;
  /**
   * 取消理由 比较(contains)
   */
  private String reasonForCancellationContains;
  /**
   * 取消理由 比较(notcontains)
   */
  private String reasonForCancellationNotcontains;
  /**
   * 取消理由 比较(startswith)
   */
  private String reasonForCancellationStartswith;
  /**
   * 取消理由 比较(endswith)
   */
  private String reasonForCancellationEndswith;
  /**
   * 取消理由 比较(isnull)
   */
  private Boolean reasonForCancellationIsnull;
  /**
   * 取消理由 比较(isnotnull)
   */
  private Boolean reasonForCancellationIsnotnull;

  /**
   * 取消理由(精确搜索)
   */
  private List<String> reasonForCancellationInList;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早收货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receivingTimeStart;

  /**
   * 最晚收货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receivingTimeEnd;

  /**
   * 收货时间 比较(eq)
   */
  private Date receivingTimeEq;
  /**
   * 收货时间 比较(neq)
   */
  private Date receivingTimeNeq;
  /**
   * 收货时间 比较(gt)
   */
  private Date receivingTimeGt;
  /**
   * 收货时间 比较(gte)
   */
  private Date receivingTimeGte;
  /**
   * 收货时间 比较(lt)
   */
  private Date receivingTimeLt;
  /**
   * 收货时间 比较(lte)
   */
  private Date receivingTimeLte;
  /**
   * 收货时间 比较(contains)
   */
  private Date receivingTimeContains;
  /**
   * 收货时间 比较(notcontains)
   */
  private Date receivingTimeNotcontains;
  /**
   * 收货时间 比较(startswith)
   */
  private Date receivingTimeStartswith;
  /**
   * 收货时间 比较(endswith)
   */
  private Date receivingTimeEndswith;
  /**
   * 收货时间 比较(isnull)
   */
  private Boolean receivingTimeIsnull;
  /**
   * 收货时间 比较(isnotnull)
   */
  private Boolean receivingTimeIsnotnull;

  /**
   * 退款备注(模糊搜索)
   */
  private String refundRemarks;

  /**
   * 退款备注 比较(eq)
   */
  private String refundRemarksEq;
  /**
   * 退款备注 比较(neq)
   */
  private String refundRemarksNeq;
  /**
   * 退款备注 比较(gt)
   */
  private String refundRemarksGt;
  /**
   * 退款备注 比较(gte)
   */
  private String refundRemarksGte;
  /**
   * 退款备注 比较(lt)
   */
  private String refundRemarksLt;
  /**
   * 退款备注 比较(lte)
   */
  private String refundRemarksLte;
  /**
   * 退款备注 比较(contains)
   */
  private String refundRemarksContains;
  /**
   * 退款备注 比较(notcontains)
   */
  private String refundRemarksNotcontains;
  /**
   * 退款备注 比较(startswith)
   */
  private String refundRemarksStartswith;
  /**
   * 退款备注 比较(endswith)
   */
  private String refundRemarksEndswith;
  /**
   * 退款备注 比较(isnull)
   */
  private Boolean refundRemarksIsnull;
  /**
   * 退款备注 比较(isnotnull)
   */
  private Boolean refundRemarksIsnotnull;

  /**
   * 退款备注(精确搜索)
   */
  private List<String> refundRemarksInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 回寄物流信息(模糊搜索)
   */
  private String returnLogisticsNo;

  /**
   * 回寄物流信息 比较(eq)
   */
  private String returnLogisticsNoEq;
  /**
   * 回寄物流信息 比较(neq)
   */
  private String returnLogisticsNoNeq;
  /**
   * 回寄物流信息 比较(gt)
   */
  private String returnLogisticsNoGt;
  /**
   * 回寄物流信息 比较(gte)
   */
  private String returnLogisticsNoGte;
  /**
   * 回寄物流信息 比较(lt)
   */
  private String returnLogisticsNoLt;
  /**
   * 回寄物流信息 比较(lte)
   */
  private String returnLogisticsNoLte;
  /**
   * 回寄物流信息 比较(contains)
   */
  private String returnLogisticsNoContains;
  /**
   * 回寄物流信息 比较(notcontains)
   */
  private String returnLogisticsNoNotcontains;
  /**
   * 回寄物流信息 比较(startswith)
   */
  private String returnLogisticsNoStartswith;
  /**
   * 回寄物流信息 比较(endswith)
   */
  private String returnLogisticsNoEndswith;
  /**
   * 回寄物流信息 比较(isnull)
   */
  private Boolean returnLogisticsNoIsnull;
  /**
   * 回寄物流信息 比较(isnotnull)
   */
  private Boolean returnLogisticsNoIsnotnull;

  /**
   * 回寄物流信息(精确搜索)
   */
  private List<String> returnLogisticsNoInList;

  /**
   * 方案id
   */
  private Long schemeId;

  /**
   * 最小方案id
   */
  private Long schemeIdMin;

  /**
   * 最大方案id
   */
  private Long schemeIdMax;

  /**
   * 方案id 比较(eq)
   */
  private Long schemeIdEq;
  /**
   * 方案id 比较(neq)
   */
  private Long schemeIdNeq;
  /**
   * 方案id 比较(gt)
   */
  private Long schemeIdGt;
  /**
   * 方案id 比较(gte)
   */
  private Long schemeIdGte;
  /**
   * 方案id 比较(lt)
   */
  private Long schemeIdLt;
  /**
   * 方案id 比较(lte)
   */
  private Long schemeIdLte;
  /**
   * 方案id 比较(contains)
   */
  private Long schemeIdContains;
  /**
   * 方案id 比较(notcontains)
   */
  private Long schemeIdNotcontains;
  /**
   * 方案id 比较(startswith)
   */
  private Long schemeIdStartswith;
  /**
   * 方案id 比较(endswith)
   */
  private Long schemeIdEndswith;
  /**
   * 方案id 比较(isnull)
   */
  private Boolean schemeIdIsnull;
  /**
   * 方案id 比较(isnotnull)
   */
  private Boolean schemeIdIsnotnull;

  /**
   * 地址(模糊搜索)
   */
  private String shippingAddress;

  /**
   * 地址 比较(eq)
   */
  private String shippingAddressEq;
  /**
   * 地址 比较(neq)
   */
  private String shippingAddressNeq;
  /**
   * 地址 比较(gt)
   */
  private String shippingAddressGt;
  /**
   * 地址 比较(gte)
   */
  private String shippingAddressGte;
  /**
   * 地址 比较(lt)
   */
  private String shippingAddressLt;
  /**
   * 地址 比较(lte)
   */
  private String shippingAddressLte;
  /**
   * 地址 比较(contains)
   */
  private String shippingAddressContains;
  /**
   * 地址 比较(notcontains)
   */
  private String shippingAddressNotcontains;
  /**
   * 地址 比较(startswith)
   */
  private String shippingAddressStartswith;
  /**
   * 地址 比较(endswith)
   */
  private String shippingAddressEndswith;
  /**
   * 地址 比较(isnull)
   */
  private Boolean shippingAddressIsnull;
  /**
   * 地址 比较(isnotnull)
   */
  private Boolean shippingAddressIsnotnull;

  /**
   * 地址(精确搜索)
   */
  private List<String> shippingAddressInList;

  /**
   * 城市(模糊搜索)
   */
  private String shippingCity;

  /**
   * 城市 比较(eq)
   */
  private String shippingCityEq;
  /**
   * 城市 比较(neq)
   */
  private String shippingCityNeq;
  /**
   * 城市 比较(gt)
   */
  private String shippingCityGt;
  /**
   * 城市 比较(gte)
   */
  private String shippingCityGte;
  /**
   * 城市 比较(lt)
   */
  private String shippingCityLt;
  /**
   * 城市 比较(lte)
   */
  private String shippingCityLte;
  /**
   * 城市 比较(contains)
   */
  private String shippingCityContains;
  /**
   * 城市 比较(notcontains)
   */
  private String shippingCityNotcontains;
  /**
   * 城市 比较(startswith)
   */
  private String shippingCityStartswith;
  /**
   * 城市 比较(endswith)
   */
  private String shippingCityEndswith;
  /**
   * 城市 比较(isnull)
   */
  private Boolean shippingCityIsnull;
  /**
   * 城市 比较(isnotnull)
   */
  private Boolean shippingCityIsnotnull;

  /**
   * 城市(精确搜索)
   */
  private List<String> shippingCityInList;

  /**
   * 国家(模糊搜索)
   */
  private String shippingCountry;

  /**
   * 国家 比较(eq)
   */
  private String shippingCountryEq;
  /**
   * 国家 比较(neq)
   */
  private String shippingCountryNeq;
  /**
   * 国家 比较(gt)
   */
  private String shippingCountryGt;
  /**
   * 国家 比较(gte)
   */
  private String shippingCountryGte;
  /**
   * 国家 比较(lt)
   */
  private String shippingCountryLt;
  /**
   * 国家 比较(lte)
   */
  private String shippingCountryLte;
  /**
   * 国家 比较(contains)
   */
  private String shippingCountryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String shippingCountryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String shippingCountryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String shippingCountryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean shippingCountryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean shippingCountryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> shippingCountryInList;

  /**
   * 州(模糊搜索)
   */
  private String shippingState;

  /**
   * 州 比较(eq)
   */
  private String shippingStateEq;
  /**
   * 州 比较(neq)
   */
  private String shippingStateNeq;
  /**
   * 州 比较(gt)
   */
  private String shippingStateGt;
  /**
   * 州 比较(gte)
   */
  private String shippingStateGte;
  /**
   * 州 比较(lt)
   */
  private String shippingStateLt;
  /**
   * 州 比较(lte)
   */
  private String shippingStateLte;
  /**
   * 州 比较(contains)
   */
  private String shippingStateContains;
  /**
   * 州 比较(notcontains)
   */
  private String shippingStateNotcontains;
  /**
   * 州 比较(startswith)
   */
  private String shippingStateStartswith;
  /**
   * 州 比较(endswith)
   */
  private String shippingStateEndswith;
  /**
   * 州 比较(isnull)
   */
  private Boolean shippingStateIsnull;
  /**
   * 州 比较(isnotnull)
   */
  private Boolean shippingStateIsnotnull;

  /**
   * 州(精确搜索)
   */
  private List<String> shippingStateInList;

  /**
   * 街道(模糊搜索)
   */
  private String shippingStreet;

  /**
   * 街道 比较(eq)
   */
  private String shippingStreetEq;
  /**
   * 街道 比较(neq)
   */
  private String shippingStreetNeq;
  /**
   * 街道 比较(gt)
   */
  private String shippingStreetGt;
  /**
   * 街道 比较(gte)
   */
  private String shippingStreetGte;
  /**
   * 街道 比较(lt)
   */
  private String shippingStreetLt;
  /**
   * 街道 比较(lte)
   */
  private String shippingStreetLte;
  /**
   * 街道 比较(contains)
   */
  private String shippingStreetContains;
  /**
   * 街道 比较(notcontains)
   */
  private String shippingStreetNotcontains;
  /**
   * 街道 比较(startswith)
   */
  private String shippingStreetStartswith;
  /**
   * 街道 比较(endswith)
   */
  private String shippingStreetEndswith;
  /**
   * 街道 比较(isnull)
   */
  private Boolean shippingStreetIsnull;
  /**
   * 街道 比较(isnotnull)
   */
  private Boolean shippingStreetIsnotnull;

  /**
   * 街道(精确搜索)
   */
  private List<String> shippingStreetInList;

  /**
   * 邮编(模糊搜索)
   */
  private String shippingZipCode;

  /**
   * 邮编 比较(eq)
   */
  private String shippingZipCodeEq;
  /**
   * 邮编 比较(neq)
   */
  private String shippingZipCodeNeq;
  /**
   * 邮编 比较(gt)
   */
  private String shippingZipCodeGt;
  /**
   * 邮编 比较(gte)
   */
  private String shippingZipCodeGte;
  /**
   * 邮编 比较(lt)
   */
  private String shippingZipCodeLt;
  /**
   * 邮编 比较(lte)
   */
  private String shippingZipCodeLte;
  /**
   * 邮编 比较(contains)
   */
  private String shippingZipCodeContains;
  /**
   * 邮编 比较(notcontains)
   */
  private String shippingZipCodeNotcontains;
  /**
   * 邮编 比较(startswith)
   */
  private String shippingZipCodeStartswith;
  /**
   * 邮编 比较(endswith)
   */
  private String shippingZipCodeEndswith;
  /**
   * 邮编 比较(isnull)
   */
  private Boolean shippingZipCodeIsnull;
  /**
   * 邮编 比较(isnotnull)
   */
  private Boolean shippingZipCodeIsnotnull;

  /**
   * 邮编(精确搜索)
   */
  private List<String> shippingZipCodeInList;

  /**
   * 规格id
   */
  private Long specificationsId;

  /**
   * 最小规格id
   */
  private Long specificationsIdMin;

  /**
   * 最大规格id
   */
  private Long specificationsIdMax;

  /**
   * 规格id 比较(eq)
   */
  private Long specificationsIdEq;
  /**
   * 规格id 比较(neq)
   */
  private Long specificationsIdNeq;
  /**
   * 规格id 比较(gt)
   */
  private Long specificationsIdGt;
  /**
   * 规格id 比较(gte)
   */
  private Long specificationsIdGte;
  /**
   * 规格id 比较(lt)
   */
  private Long specificationsIdLt;
  /**
   * 规格id 比较(lte)
   */
  private Long specificationsIdLte;
  /**
   * 规格id 比较(contains)
   */
  private Long specificationsIdContains;
  /**
   * 规格id 比较(notcontains)
   */
  private Long specificationsIdNotcontains;
  /**
   * 规格id 比较(startswith)
   */
  private Long specificationsIdStartswith;
  /**
   * 规格id 比较(endswith)
   */
  private Long specificationsIdEndswith;
  /**
   * 规格id 比较(isnull)
   */
  private Boolean specificationsIdIsnull;
  /**
   * 规格id 比较(isnotnull)
   */
  private Boolean specificationsIdIsnotnull;

  /**
   * 状态(模糊搜索)
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 最早提交时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date submissionTimeStart;

  /**
   * 最晚提交时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date submissionTimeEnd;

  /**
   * 提交时间 比较(eq)
   */
  private Date submissionTimeEq;
  /**
   * 提交时间 比较(neq)
   */
  private Date submissionTimeNeq;
  /**
   * 提交时间 比较(gt)
   */
  private Date submissionTimeGt;
  /**
   * 提交时间 比较(gte)
   */
  private Date submissionTimeGte;
  /**
   * 提交时间 比较(lt)
   */
  private Date submissionTimeLt;
  /**
   * 提交时间 比较(lte)
   */
  private Date submissionTimeLte;
  /**
   * 提交时间 比较(contains)
   */
  private Date submissionTimeContains;
  /**
   * 提交时间 比较(notcontains)
   */
  private Date submissionTimeNotcontains;
  /**
   * 提交时间 比较(startswith)
   */
  private Date submissionTimeStartswith;
  /**
   * 提交时间 比较(endswith)
   */
  private Date submissionTimeEndswith;
  /**
   * 提交时间 比较(isnull)
   */
  private Boolean submissionTimeIsnull;
  /**
   * 提交时间 比较(isnotnull)
   */
  private Boolean submissionTimeIsnotnull;

  /**
   * 总价
   */
  private java.math.BigDecimal total;

  /**
   * 最小总价
   */
  private java.math.BigDecimal totalMin;

  /**
   * 最大总价
   */
  private java.math.BigDecimal totalMax;

  /**
   * 总价 比较(eq)
   */
  private java.math.BigDecimal totalEq;
  /**
   * 总价 比较(neq)
   */
  private java.math.BigDecimal totalNeq;
  /**
   * 总价 比较(gt)
   */
  private java.math.BigDecimal totalGt;
  /**
   * 总价 比较(gte)
   */
  private java.math.BigDecimal totalGte;
  /**
   * 总价 比较(lt)
   */
  private java.math.BigDecimal totalLt;
  /**
   * 总价 比较(lte)
   */
  private java.math.BigDecimal totalLte;
  /**
   * 总价 比较(contains)
   */
  private java.math.BigDecimal totalContains;
  /**
   * 总价 比较(notcontains)
   */
  private java.math.BigDecimal totalNotcontains;
  /**
   * 总价 比较(startswith)
   */
  private java.math.BigDecimal totalStartswith;
  /**
   * 总价 比较(endswith)
   */
  private java.math.BigDecimal totalEndswith;
  /**
   * 总价 比较(isnull)
   */
  private Boolean totalIsnull;
  /**
   * 总价 比较(isnotnull)
   */
  private Boolean totalIsnotnull;

  /**
   * 促销码(模糊搜索)
   */
  private String activityId;

  /**
   * 促销码 比较(eq)
   */
  private String activityIdEq;
  /**
   * 促销码 比较(neq)
   */
  private String activityIdNeq;
  /**
   * 促销码 比较(gt)
   */
  private String activityIdGt;
  /**
   * 促销码 比较(gte)
   */
  private String activityIdGte;
  /**
   * 促销码 比较(lt)
   */
  private String activityIdLt;
  /**
   * 促销码 比较(lte)
   */
  private String activityIdLte;
  /**
   * 促销码 比较(contains)
   */
  private String activityIdContains;
  /**
   * 促销码 比较(notcontains)
   */
  private String activityIdNotcontains;
  /**
   * 促销码 比较(startswith)
   */
  private String activityIdStartswith;
  /**
   * 促销码 比较(endswith)
   */
  private String activityIdEndswith;
  /**
   * 促销码 比较(isnull)
   */
  private Boolean activityIdIsnull;
  /**
   * 促销码 比较(isnotnull)
   */
  private Boolean activityIdIsnotnull;

  /**
   * 促销码(精确搜索)
   */
  private List<String> activityIdInList;

  /**
   * 收货地址(模糊搜索)
   */
  private String address;

  /**
   * 收货地址 比较(eq)
   */
  private String addressEq;
  /**
   * 收货地址 比较(neq)
   */
  private String addressNeq;
  /**
   * 收货地址 比较(gt)
   */
  private String addressGt;
  /**
   * 收货地址 比较(gte)
   */
  private String addressGte;
  /**
   * 收货地址 比较(lt)
   */
  private String addressLt;
  /**
   * 收货地址 比较(lte)
   */
  private String addressLte;
  /**
   * 收货地址 比较(contains)
   */
  private String addressContains;
  /**
   * 收货地址 比较(notcontains)
   */
  private String addressNotcontains;
  /**
   * 收货地址 比较(startswith)
   */
  private String addressStartswith;
  /**
   * 收货地址 比较(endswith)
   */
  private String addressEndswith;
  /**
   * 收货地址 比较(isnull)
   */
  private Boolean addressIsnull;
  /**
   * 收货地址 比较(isnotnull)
   */
  private Boolean addressIsnotnull;

  /**
   * 收货地址(精确搜索)
   */
  private List<String> addressInList;

  /**
   * 售后状态 用于取消售后订单状态还原(模糊搜索)
   */
  private String afterStatus;

  /**
   * 售后状态 用于取消售后订单状态还原 比较(eq)
   */
  private String afterStatusEq;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(neq)
   */
  private String afterStatusNeq;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(gt)
   */
  private String afterStatusGt;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(gte)
   */
  private String afterStatusGte;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(lt)
   */
  private String afterStatusLt;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(lte)
   */
  private String afterStatusLte;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(contains)
   */
  private String afterStatusContains;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(notcontains)
   */
  private String afterStatusNotcontains;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(startswith)
   */
  private String afterStatusStartswith;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(endswith)
   */
  private String afterStatusEndswith;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(isnull)
   */
  private Boolean afterStatusIsnull;
  /**
   * 售后状态 用于取消售后订单状态还原 比较(isnotnull)
   */
  private Boolean afterStatusIsnotnull;

  /**
   * 售后状态 用于取消售后订单状态还原(精确搜索)
   */
  private List<String> afterStatusInList;

  /**
   * 申请售后状态(模糊搜索)
   */
  private String applyStatus;

  /**
   * 申请售后状态 比较(eq)
   */
  private String applyStatusEq;
  /**
   * 申请售后状态 比较(neq)
   */
  private String applyStatusNeq;
  /**
   * 申请售后状态 比较(gt)
   */
  private String applyStatusGt;
  /**
   * 申请售后状态 比较(gte)
   */
  private String applyStatusGte;
  /**
   * 申请售后状态 比较(lt)
   */
  private String applyStatusLt;
  /**
   * 申请售后状态 比较(lte)
   */
  private String applyStatusLte;
  /**
   * 申请售后状态 比较(contains)
   */
  private String applyStatusContains;
  /**
   * 申请售后状态 比较(notcontains)
   */
  private String applyStatusNotcontains;
  /**
   * 申请售后状态 比较(startswith)
   */
  private String applyStatusStartswith;
  /**
   * 申请售后状态 比较(endswith)
   */
  private String applyStatusEndswith;
  /**
   * 申请售后状态 比较(isnull)
   */
  private Boolean applyStatusIsnull;
  /**
   * 申请售后状态 比较(isnotnull)
   */
  private Boolean applyStatusIsnotnull;

  /**
   * 申请售后状态(精确搜索)
   */
  private List<String> applyStatusInList;

  /**
   * 是否为后台创建订单
   */
  private Boolean backendCreate;

  /**
   * 是否为后台创建订单
   */
  private String backendCreateEq;

  /**
   * 账单地址(模糊搜索)
   */
  private String billAddress;

  /**
   * 账单地址 比较(eq)
   */
  private String billAddressEq;
  /**
   * 账单地址 比较(neq)
   */
  private String billAddressNeq;
  /**
   * 账单地址 比较(gt)
   */
  private String billAddressGt;
  /**
   * 账单地址 比较(gte)
   */
  private String billAddressGte;
  /**
   * 账单地址 比较(lt)
   */
  private String billAddressLt;
  /**
   * 账单地址 比较(lte)
   */
  private String billAddressLte;
  /**
   * 账单地址 比较(contains)
   */
  private String billAddressContains;
  /**
   * 账单地址 比较(notcontains)
   */
  private String billAddressNotcontains;
  /**
   * 账单地址 比较(startswith)
   */
  private String billAddressStartswith;
  /**
   * 账单地址 比较(endswith)
   */
  private String billAddressEndswith;
  /**
   * 账单地址 比较(isnull)
   */
  private Boolean billAddressIsnull;
  /**
   * 账单地址 比较(isnotnull)
   */
  private Boolean billAddressIsnotnull;

  /**
   * 账单地址(精确搜索)
   */
  private List<String> billAddressInList;

  /**
   * 用户取消备注(模糊搜索)
   */
  private String cancelRemarks;

  /**
   * 用户取消备注 比较(eq)
   */
  private String cancelRemarksEq;
  /**
   * 用户取消备注 比较(neq)
   */
  private String cancelRemarksNeq;
  /**
   * 用户取消备注 比较(gt)
   */
  private String cancelRemarksGt;
  /**
   * 用户取消备注 比较(gte)
   */
  private String cancelRemarksGte;
  /**
   * 用户取消备注 比较(lt)
   */
  private String cancelRemarksLt;
  /**
   * 用户取消备注 比较(lte)
   */
  private String cancelRemarksLte;
  /**
   * 用户取消备注 比较(contains)
   */
  private String cancelRemarksContains;
  /**
   * 用户取消备注 比较(notcontains)
   */
  private String cancelRemarksNotcontains;
  /**
   * 用户取消备注 比较(startswith)
   */
  private String cancelRemarksStartswith;
  /**
   * 用户取消备注 比较(endswith)
   */
  private String cancelRemarksEndswith;
  /**
   * 用户取消备注 比较(isnull)
   */
  private Boolean cancelRemarksIsnull;
  /**
   * 用户取消备注 比较(isnotnull)
   */
  private Boolean cancelRemarksIsnotnull;

  /**
   * 用户取消备注(精确搜索)
   */
  private List<String> cancelRemarksInList;

  /**
   * 调价金额
   */
  private java.math.BigDecimal change;

  /**
   * 最小调价金额
   */
  private java.math.BigDecimal changeMin;

  /**
   * 最大调价金额
   */
  private java.math.BigDecimal changeMax;

  /**
   * 调价金额 比较(eq)
   */
  private java.math.BigDecimal changeEq;
  /**
   * 调价金额 比较(neq)
   */
  private java.math.BigDecimal changeNeq;
  /**
   * 调价金额 比较(gt)
   */
  private java.math.BigDecimal changeGt;
  /**
   * 调价金额 比较(gte)
   */
  private java.math.BigDecimal changeGte;
  /**
   * 调价金额 比较(lt)
   */
  private java.math.BigDecimal changeLt;
  /**
   * 调价金额 比较(lte)
   */
  private java.math.BigDecimal changeLte;
  /**
   * 调价金额 比较(contains)
   */
  private java.math.BigDecimal changeContains;
  /**
   * 调价金额 比较(notcontains)
   */
  private java.math.BigDecimal changeNotcontains;
  /**
   * 调价金额 比较(startswith)
   */
  private java.math.BigDecimal changeStartswith;
  /**
   * 调价金额 比较(endswith)
   */
  private java.math.BigDecimal changeEndswith;
  /**
   * 调价金额 比较(isnull)
   */
  private Boolean changeIsnull;
  /**
   * 调价金额 比较(isnotnull)
   */
  private Boolean changeIsnotnull;

  /**
   * 礼品卡编码(模糊搜索)
   */
  private String code;

  /**
   * 礼品卡编码 比较(eq)
   */
  private String codeEq;
  /**
   * 礼品卡编码 比较(neq)
   */
  private String codeNeq;
  /**
   * 礼品卡编码 比较(gt)
   */
  private String codeGt;
  /**
   * 礼品卡编码 比较(gte)
   */
  private String codeGte;
  /**
   * 礼品卡编码 比较(lt)
   */
  private String codeLt;
  /**
   * 礼品卡编码 比较(lte)
   */
  private String codeLte;
  /**
   * 礼品卡编码 比较(contains)
   */
  private String codeContains;
  /**
   * 礼品卡编码 比较(notcontains)
   */
  private String codeNotcontains;
  /**
   * 礼品卡编码 比较(startswith)
   */
  private String codeStartswith;
  /**
   * 礼品卡编码 比较(endswith)
   */
  private String codeEndswith;
  /**
   * 礼品卡编码 比较(isnull)
   */
  private Boolean codeIsnull;
  /**
   * 礼品卡编码 比较(isnotnull)
   */
  private Boolean codeIsnotnull;

  /**
   * 礼品卡编码(精确搜索)
   */
  private List<String> codeInList;

  /**
   * 最早完成时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date completionTimeStart;

  /**
   * 最晚完成时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date completionTimeEnd;

  /**
   * 完成时间 比较(eq)
   */
  private Date completionTimeEq;
  /**
   * 完成时间 比较(neq)
   */
  private Date completionTimeNeq;
  /**
   * 完成时间 比较(gt)
   */
  private Date completionTimeGt;
  /**
   * 完成时间 比较(gte)
   */
  private Date completionTimeGte;
  /**
   * 完成时间 比较(lt)
   */
  private Date completionTimeLt;
  /**
   * 完成时间 比较(lte)
   */
  private Date completionTimeLte;
  /**
   * 完成时间 比较(contains)
   */
  private Date completionTimeContains;
  /**
   * 完成时间 比较(notcontains)
   */
  private Date completionTimeNotcontains;
  /**
   * 完成时间 比较(startswith)
   */
  private Date completionTimeStartswith;
  /**
   * 完成时间 比较(endswith)
   */
  private Date completionTimeEndswith;
  /**
   * 完成时间 比较(isnull)
   */
  private Boolean completionTimeIsnull;
  /**
   * 完成时间 比较(isnotnull)
   */
  private Boolean completionTimeIsnotnull;

  /**
   * 收货人(模糊搜索)
   */
  private String consignee;

  /**
   * 收货人 比较(eq)
   */
  private String consigneeEq;
  /**
   * 收货人 比较(neq)
   */
  private String consigneeNeq;
  /**
   * 收货人 比较(gt)
   */
  private String consigneeGt;
  /**
   * 收货人 比较(gte)
   */
  private String consigneeGte;
  /**
   * 收货人 比较(lt)
   */
  private String consigneeLt;
  /**
   * 收货人 比较(lte)
   */
  private String consigneeLte;
  /**
   * 收货人 比较(contains)
   */
  private String consigneeContains;
  /**
   * 收货人 比较(notcontains)
   */
  private String consigneeNotcontains;
  /**
   * 收货人 比较(startswith)
   */
  private String consigneeStartswith;
  /**
   * 收货人 比较(endswith)
   */
  private String consigneeEndswith;
  /**
   * 收货人 比较(isnull)
   */
  private Boolean consigneeIsnull;
  /**
   * 收货人 比较(isnotnull)
   */
  private Boolean consigneeIsnotnull;

  /**
   * 收货人(精确搜索)
   */
  private List<String> consigneeInList;

  /**
   * 用户id
   */
  private Long consumerId;

  /**
   * 最小用户id
   */
  private Long consumerIdMin;

  /**
   * 最大用户id
   */
  private Long consumerIdMax;

  /**
   * 用户id 比较(eq)
   */
  private Long consumerIdEq;
  /**
   * 用户id 比较(neq)
   */
  private Long consumerIdNeq;
  /**
   * 用户id 比较(gt)
   */
  private Long consumerIdGt;
  /**
   * 用户id 比较(gte)
   */
  private Long consumerIdGte;
  /**
   * 用户id 比较(lt)
   */
  private Long consumerIdLt;
  /**
   * 用户id 比较(lte)
   */
  private Long consumerIdLte;
  /**
   * 用户id 比较(contains)
   */
  private Long consumerIdContains;
  /**
   * 用户id 比较(notcontains)
   */
  private Long consumerIdNotcontains;
  /**
   * 用户id 比较(startswith)
   */
  private Long consumerIdStartswith;
  /**
   * 用户id 比较(endswith)
   */
  private Long consumerIdEndswith;
  /**
   * 用户id 比较(isnull)
   */
  private Boolean consumerIdIsnull;
  /**
   * 用户id 比较(isnotnull)
   */
  private Boolean consumerIdIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 币种
   */
  private Long currencyExchangeRateId;

  /**
   * 最小币种
   */
  private Long currencyExchangeRateIdMin;

  /**
   * 最大币种
   */
  private Long currencyExchangeRateIdMax;

  /**
   * 币种 比较(eq)
   */
  private Long currencyExchangeRateIdEq;
  /**
   * 币种 比较(neq)
   */
  private Long currencyExchangeRateIdNeq;
  /**
   * 币种 比较(gt)
   */
  private Long currencyExchangeRateIdGt;
  /**
   * 币种 比较(gte)
   */
  private Long currencyExchangeRateIdGte;
  /**
   * 币种 比较(lt)
   */
  private Long currencyExchangeRateIdLt;
  /**
   * 币种 比较(lte)
   */
  private Long currencyExchangeRateIdLte;
  /**
   * 币种 比较(contains)
   */
  private Long currencyExchangeRateIdContains;
  /**
   * 币种 比较(notcontains)
   */
  private Long currencyExchangeRateIdNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private Long currencyExchangeRateIdStartswith;
  /**
   * 币种 比较(endswith)
   */
  private Long currencyExchangeRateIdEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean currencyExchangeRateIdIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean currencyExchangeRateIdIsnotnull;

  /**
   * 副戒id
   */
  private Long accessoryRingId;

  /**
   * 最小副戒id
   */
  private Long accessoryRingIdMin;

  /**
   * 最大副戒id
   */
  private Long accessoryRingIdMax;

  /**
   * 副戒id 比较(eq)
   */
  private Long accessoryRingIdEq;
  /**
   * 副戒id 比较(neq)
   */
  private Long accessoryRingIdNeq;
  /**
   * 副戒id 比较(gt)
   */
  private Long accessoryRingIdGt;
  /**
   * 副戒id 比较(gte)
   */
  private Long accessoryRingIdGte;
  /**
   * 副戒id 比较(lt)
   */
  private Long accessoryRingIdLt;
  /**
   * 副戒id 比较(lte)
   */
  private Long accessoryRingIdLte;
  /**
   * 副戒id 比较(contains)
   */
  private Long accessoryRingIdContains;
  /**
   * 副戒id 比较(notcontains)
   */
  private Long accessoryRingIdNotcontains;
  /**
   * 副戒id 比较(startswith)
   */
  private Long accessoryRingIdStartswith;
  /**
   * 副戒id 比较(endswith)
   */
  private Long accessoryRingIdEndswith;
  /**
   * 副戒id 比较(isnull)
   */
  private Boolean accessoryRingIdIsnull;
  /**
   * 副戒id 比较(isnotnull)
   */
  private Boolean accessoryRingIdIsnotnull;

  /**
   * 最早发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryTimeStart;

  /**
   * 最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryTimeEnd;

  /**
   * 发货时间 比较(eq)
   */
  private Date deliveryTimeEq;
  /**
   * 发货时间 比较(neq)
   */
  private Date deliveryTimeNeq;
  /**
   * 发货时间 比较(gt)
   */
  private Date deliveryTimeGt;
  /**
   * 发货时间 比较(gte)
   */
  private Date deliveryTimeGte;
  /**
   * 发货时间 比较(lt)
   */
  private Date deliveryTimeLt;
  /**
   * 发货时间 比较(lte)
   */
  private Date deliveryTimeLte;
  /**
   * 发货时间 比较(contains)
   */
  private Date deliveryTimeContains;
  /**
   * 发货时间 比较(notcontains)
   */
  private Date deliveryTimeNotcontains;
  /**
   * 发货时间 比较(startswith)
   */
  private Date deliveryTimeStartswith;
  /**
   * 发货时间 比较(endswith)
   */
  private Date deliveryTimeEndswith;
  /**
   * 发货时间 比较(isnull)
   */
  private Boolean deliveryTimeIsnull;
  /**
   * 发货时间 比较(isnotnull)
   */
  private Boolean deliveryTimeIsnotnull;

  /**
   * 优惠价格
   */
  private java.math.BigDecimal discountMoney;

  /**
   * 最小优惠价格
   */
  private java.math.BigDecimal discountMoneyMin;

  /**
   * 最大优惠价格
   */
  private java.math.BigDecimal discountMoneyMax;

  /**
   * 优惠价格 比较(eq)
   */
  private java.math.BigDecimal discountMoneyEq;
  /**
   * 优惠价格 比较(neq)
   */
  private java.math.BigDecimal discountMoneyNeq;
  /**
   * 优惠价格 比较(gt)
   */
  private java.math.BigDecimal discountMoneyGt;
  /**
   * 优惠价格 比较(gte)
   */
  private java.math.BigDecimal discountMoneyGte;
  /**
   * 优惠价格 比较(lt)
   */
  private java.math.BigDecimal discountMoneyLt;
  /**
   * 优惠价格 比较(lte)
   */
  private java.math.BigDecimal discountMoneyLte;
  /**
   * 优惠价格 比较(contains)
   */
  private java.math.BigDecimal discountMoneyContains;
  /**
   * 优惠价格 比较(notcontains)
   */
  private java.math.BigDecimal discountMoneyNotcontains;
  /**
   * 优惠价格 比较(startswith)
   */
  private java.math.BigDecimal discountMoneyStartswith;
  /**
   * 优惠价格 比较(endswith)
   */
  private java.math.BigDecimal discountMoneyEndswith;
  /**
   * 优惠价格 比较(isnull)
   */
  private Boolean discountMoneyIsnull;
  /**
   * 优惠价格 比较(isnotnull)
   */
  private Boolean discountMoneyIsnotnull;

  /**
   * 积分
   */
  private Long earnPoints;

  /**
   * 最小积分
   */
  private Long earnPointsMin;

  /**
   * 最大积分
   */
  private Long earnPointsMax;

  /**
   * 积分 比较(eq)
   */
  private Long earnPointsEq;
  /**
   * 积分 比较(neq)
   */
  private Long earnPointsNeq;
  /**
   * 积分 比较(gt)
   */
  private Long earnPointsGt;
  /**
   * 积分 比较(gte)
   */
  private Long earnPointsGte;
  /**
   * 积分 比较(lt)
   */
  private Long earnPointsLt;
  /**
   * 积分 比较(lte)
   */
  private Long earnPointsLte;
  /**
   * 积分 比较(contains)
   */
  private Long earnPointsContains;
  /**
   * 积分 比较(notcontains)
   */
  private Long earnPointsNotcontains;
  /**
   * 积分 比较(startswith)
   */
  private Long earnPointsStartswith;
  /**
   * 积分 比较(endswith)
   */
  private Long earnPointsEndswith;
  /**
   * 积分 比较(isnull)
   */
  private Boolean earnPointsIsnull;
  /**
   * 积分 比较(isnotnull)
   */
  private Boolean earnPointsIsnotnull;

  /**
   * 邮箱(模糊搜索)
   */
  private String email;

  /**
   * 邮箱 比较(eq)
   */
  private String emailEq;
  /**
   * 邮箱 比较(neq)
   */
  private String emailNeq;
  /**
   * 邮箱 比较(gt)
   */
  private String emailGt;
  /**
   * 邮箱 比较(gte)
   */
  private String emailGte;
  /**
   * 邮箱 比较(lt)
   */
  private String emailLt;
  /**
   * 邮箱 比较(lte)
   */
  private String emailLte;
  /**
   * 邮箱 比较(contains)
   */
  private String emailContains;
  /**
   * 邮箱 比较(notcontains)
   */
  private String emailNotcontains;
  /**
   * 邮箱 比较(startswith)
   */
  private String emailStartswith;
  /**
   * 邮箱 比较(endswith)
   */
  private String emailEndswith;
  /**
   * 邮箱 比较(isnull)
   */
  private Boolean emailIsnull;
  /**
   * 邮箱 比较(isnotnull)
   */
  private Boolean emailIsnotnull;

  /**
   * 邮箱(精确搜索)
   */
  private List<String> emailInList;

  /**
   * 运费
   */
  private java.math.BigDecimal freightPrice;

  /**
   * 最小运费
   */
  private java.math.BigDecimal freightPriceMin;

  /**
   * 最大运费
   */
  private java.math.BigDecimal freightPriceMax;

  /**
   * 运费 比较(eq)
   */
  private java.math.BigDecimal freightPriceEq;
  /**
   * 运费 比较(neq)
   */
  private java.math.BigDecimal freightPriceNeq;
  /**
   * 运费 比较(gt)
   */
  private java.math.BigDecimal freightPriceGt;
  /**
   * 运费 比较(gte)
   */
  private java.math.BigDecimal freightPriceGte;
  /**
   * 运费 比较(lt)
   */
  private java.math.BigDecimal freightPriceLt;
  /**
   * 运费 比较(lte)
   */
  private java.math.BigDecimal freightPriceLte;
  /**
   * 运费 比较(contains)
   */
  private java.math.BigDecimal freightPriceContains;
  /**
   * 运费 比较(notcontains)
   */
  private java.math.BigDecimal freightPriceNotcontains;
  /**
   * 运费 比较(startswith)
   */
  private java.math.BigDecimal freightPriceStartswith;
  /**
   * 运费 比较(endswith)
   */
  private java.math.BigDecimal freightPriceEndswith;
  /**
   * 运费 比较(isnull)
   */
  private Boolean freightPriceIsnull;
  /**
   * 运费 比较(isnotnull)
   */
  private Boolean freightPriceIsnotnull;

  /**
   * 礼品卡使用金额
   */
  private java.math.BigDecimal giftCardMoney;

  /**
   * 最小礼品卡使用金额
   */
  private java.math.BigDecimal giftCardMoneyMin;

  /**
   * 最大礼品卡使用金额
   */
  private java.math.BigDecimal giftCardMoneyMax;

  /**
   * 礼品卡使用金额 比较(eq)
   */
  private java.math.BigDecimal giftCardMoneyEq;
  /**
   * 礼品卡使用金额 比较(neq)
   */
  private java.math.BigDecimal giftCardMoneyNeq;
  /**
   * 礼品卡使用金额 比较(gt)
   */
  private java.math.BigDecimal giftCardMoneyGt;
  /**
   * 礼品卡使用金额 比较(gte)
   */
  private java.math.BigDecimal giftCardMoneyGte;
  /**
   * 礼品卡使用金额 比较(lt)
   */
  private java.math.BigDecimal giftCardMoneyLt;
  /**
   * 礼品卡使用金额 比较(lte)
   */
  private java.math.BigDecimal giftCardMoneyLte;
  /**
   * 礼品卡使用金额 比较(contains)
   */
  private java.math.BigDecimal giftCardMoneyContains;
  /**
   * 礼品卡使用金额 比较(notcontains)
   */
  private java.math.BigDecimal giftCardMoneyNotcontains;
  /**
   * 礼品卡使用金额 比较(startswith)
   */
  private java.math.BigDecimal giftCardMoneyStartswith;
  /**
   * 礼品卡使用金额 比较(endswith)
   */
  private java.math.BigDecimal giftCardMoneyEndswith;
  /**
   * 礼品卡使用金额 比较(isnull)
   */
  private Boolean giftCardMoneyIsnull;
  /**
   * 礼品卡使用金额 比较(isnotnull)
   */
  private Boolean giftCardMoneyIsnotnull;

  /**
   * 礼品包装id
   */
  private Long giftId;

  /**
   * 最小礼品包装id
   */
  private Long giftIdMin;

  /**
   * 最大礼品包装id
   */
  private Long giftIdMax;

  /**
   * 礼品包装id 比较(eq)
   */
  private Long giftIdEq;
  /**
   * 礼品包装id 比较(neq)
   */
  private Long giftIdNeq;
  /**
   * 礼品包装id 比较(gt)
   */
  private Long giftIdGt;
  /**
   * 礼品包装id 比较(gte)
   */
  private Long giftIdGte;
  /**
   * 礼品包装id 比较(lt)
   */
  private Long giftIdLt;
  /**
   * 礼品包装id 比较(lte)
   */
  private Long giftIdLte;
  /**
   * 礼品包装id 比较(contains)
   */
  private Long giftIdContains;
  /**
   * 礼品包装id 比较(notcontains)
   */
  private Long giftIdNotcontains;
  /**
   * 礼品包装id 比较(startswith)
   */
  private Long giftIdStartswith;
  /**
   * 礼品包装id 比较(endswith)
   */
  private Long giftIdEndswith;
  /**
   * 礼品包装id 比较(isnull)
   */
  private Boolean giftIdIsnull;
  /**
   * 礼品包装id 比较(isnotnull)
   */
  private Boolean giftIdIsnotnull;

  /**
   * SKU(模糊搜索)
   */
  private String goodsCode;

  /**
   * SKU 比较(eq)
   */
  private String goodsCodeEq;
  /**
   * SKU 比较(neq)
   */
  private String goodsCodeNeq;
  /**
   * SKU 比较(gt)
   */
  private String goodsCodeGt;
  /**
   * SKU 比较(gte)
   */
  private String goodsCodeGte;
  /**
   * SKU 比较(lt)
   */
  private String goodsCodeLt;
  /**
   * SKU 比较(lte)
   */
  private String goodsCodeLte;
  /**
   * SKU 比较(contains)
   */
  private String goodsCodeContains;
  /**
   * SKU 比较(notcontains)
   */
  private String goodsCodeNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String goodsCodeStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String goodsCodeEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean goodsCodeIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean goodsCodeIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> goodsCodeInList;

  /**
   * 商品id
   */
  private Long goodsId;

  /**
   * 最小商品id
   */
  private Long goodsIdMin;

  /**
   * 最大商品id
   */
  private Long goodsIdMax;

  /**
   * 商品id 比较(eq)
   */
  private Long goodsIdEq;
  /**
   * 商品id 比较(neq)
   */
  private Long goodsIdNeq;
  /**
   * 商品id 比较(gt)
   */
  private Long goodsIdGt;
  /**
   * 商品id 比较(gte)
   */
  private Long goodsIdGte;
  /**
   * 商品id 比较(lt)
   */
  private Long goodsIdLt;
  /**
   * 商品id 比较(lte)
   */
  private Long goodsIdLte;
  /**
   * 商品id 比较(contains)
   */
  private Long goodsIdContains;
  /**
   * 商品id 比较(notcontains)
   */
  private Long goodsIdNotcontains;
  /**
   * 商品id 比较(startswith)
   */
  private Long goodsIdStartswith;
  /**
   * 商品id 比较(endswith)
   */
  private Long goodsIdEndswith;
  /**
   * 商品id 比较(isnull)
   */
  private Boolean goodsIdIsnull;
  /**
   * 商品id 比较(isnotnull)
   */
  private Boolean goodsIdIsnotnull;

  /**
   * 商品名(导入数据)(模糊搜索)
   */
  private String goodsName;

  /**
   * 商品名(导入数据) 比较(eq)
   */
  private String goodsNameEq;
  /**
   * 商品名(导入数据) 比较(neq)
   */
  private String goodsNameNeq;
  /**
   * 商品名(导入数据) 比较(gt)
   */
  private String goodsNameGt;
  /**
   * 商品名(导入数据) 比较(gte)
   */
  private String goodsNameGte;
  /**
   * 商品名(导入数据) 比较(lt)
   */
  private String goodsNameLt;
  /**
   * 商品名(导入数据) 比较(lte)
   */
  private String goodsNameLte;
  /**
   * 商品名(导入数据) 比较(contains)
   */
  private String goodsNameContains;
  /**
   * 商品名(导入数据) 比较(notcontains)
   */
  private String goodsNameNotcontains;
  /**
   * 商品名(导入数据) 比较(startswith)
   */
  private String goodsNameStartswith;
  /**
   * 商品名(导入数据) 比较(endswith)
   */
  private String goodsNameEndswith;
  /**
   * 商品名(导入数据) 比较(isnull)
   */
  private Boolean goodsNameIsnull;
  /**
   * 商品名(导入数据) 比较(isnotnull)
   */
  private Boolean goodsNameIsnotnull;

  /**
   * 商品名(导入数据)(精确搜索)
   */
  private List<String> goodsNameInList;

  /**
   * 商品sku(导入数据)(模糊搜索)
   */
  private String goodsSku;

  /**
   * 商品sku(导入数据) 比较(eq)
   */
  private String goodsSkuEq;
  /**
   * 商品sku(导入数据) 比较(neq)
   */
  private String goodsSkuNeq;
  /**
   * 商品sku(导入数据) 比较(gt)
   */
  private String goodsSkuGt;
  /**
   * 商品sku(导入数据) 比较(gte)
   */
  private String goodsSkuGte;
  /**
   * 商品sku(导入数据) 比较(lt)
   */
  private String goodsSkuLt;
  /**
   * 商品sku(导入数据) 比较(lte)
   */
  private String goodsSkuLte;
  /**
   * 商品sku(导入数据) 比较(contains)
   */
  private String goodsSkuContains;
  /**
   * 商品sku(导入数据) 比较(notcontains)
   */
  private String goodsSkuNotcontains;
  /**
   * 商品sku(导入数据) 比较(startswith)
   */
  private String goodsSkuStartswith;
  /**
   * 商品sku(导入数据) 比较(endswith)
   */
  private String goodsSkuEndswith;
  /**
   * 商品sku(导入数据) 比较(isnull)
   */
  private Boolean goodsSkuIsnull;
  /**
   * 商品sku(导入数据) 比较(isnotnull)
   */
  private Boolean goodsSkuIsnotnull;

  /**
   * 商品sku(导入数据)(精确搜索)
   */
  private List<String> goodsSkuInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 免费(模糊搜索)
   */
  private String infoText;

  /**
   * 免费 比较(eq)
   */
  private String infoTextEq;
  /**
   * 免费 比较(neq)
   */
  private String infoTextNeq;
  /**
   * 免费 比较(gt)
   */
  private String infoTextGt;
  /**
   * 免费 比较(gte)
   */
  private String infoTextGte;
  /**
   * 免费 比较(lt)
   */
  private String infoTextLt;
  /**
   * 免费 比较(lte)
   */
  private String infoTextLte;
  /**
   * 免费 比较(contains)
   */
  private String infoTextContains;
  /**
   * 免费 比较(notcontains)
   */
  private String infoTextNotcontains;
  /**
   * 免费 比较(startswith)
   */
  private String infoTextStartswith;
  /**
   * 免费 比较(endswith)
   */
  private String infoTextEndswith;
  /**
   * 免费 比较(isnull)
   */
  private Boolean infoTextIsnull;
  /**
   * 免费 比较(isnotnull)
   */
  private Boolean infoTextIsnotnull;

  /**
   * 免费(精确搜索)
   */
  private List<String> infoTextInList;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 店铺id
   */
  private Long sid;

  /**
   * 最小店铺id
   */
  private Long sidMin;

  /**
   * 最大店铺id
   */
  private Long sidMax;

  /**
   * 店铺id 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺id 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺id 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺id 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺id 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺id 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺id 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
